import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

import junit.framework.TestCase;

/**
 * 
 * @author Claudio Trindade
 *
 */
public class JogoTesteCaixaBranca_Claudio extends TestCase {

	public void testDeterminaOrdem_T1() {
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		jogador1.setIdade(1);
		Jogador jogador2 = new Jogador();
		jogador2.setIdade(0);
		Jogador jogador3 = new Jogador();
		jogador3.setIdade(1);
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogadores.add(jogador3);
		jogo.setJogadores(jogadores);
		jogo.setSentidoDoJogo(Sentido.HORARIO);
		
		jogo.determinaOrdem();
		
		/*
		 * No sentido horário, quando o primeiro jogador está na penúltima posição da lista de jogadores, o próximo jogador está sendo o primeiro da lista, quando deveria ser o ultimo.
		 */
		
		assertEquals(jogador2, jogo.getJogadorAtual());
		assertEquals(jogador3, jogo.getProximoJogador());
	}
	
	public void testDeterminaOrdem_T2() {
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		jogador1.setIdade(1);
		Jogador jogador2 = new Jogador();
		jogador2.setIdade(0);
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		jogo.setSentidoDoJogo(Sentido.HORARIO);
		
		jogo.determinaOrdem();
		
		assertEquals(jogador2, jogo.getJogadorAtual());
		assertEquals(jogador1, jogo.getProximoJogador());
	}
	
	public void testDeterminaOrdem_T3() {
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		jogador1.setIdade(1);
		Jogador jogador2 = new Jogador();
		jogador2.setIdade(0);
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		jogo.setSentidoDoJogo(Sentido.ANTIHORARIO);
		
		jogo.determinaOrdem();
		
		/*
		 * No sentida anti-horário, quando o primeiro jogador está segunda posição da lista de jogadores, o próximo jogador está sendo o ultimo da lista, quando deveria ser o primeiro.
		 */
		
		assertEquals(jogador2, jogo.getJogadorAtual());
		assertEquals(jogador1, jogo.getProximoJogador());
	}
	
	public void testDeterminaOrdem_T4() {
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		jogador1.setIdade(0);
		Jogador jogador2 = new Jogador();
		jogador2.setIdade(1);
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		jogo.setSentidoDoJogo(Sentido.ANTIHORARIO);
		
		jogo.determinaOrdem();
		
		assertEquals(jogador1, jogo.getJogadorAtual());
		assertEquals(jogador2, jogo.getProximoJogador());
	}

	public void testDistribuirMaos_T1() {
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		Jogador jogador2 = new Jogador();
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		jogo.setDeck(new Baralho().getDeck());
		
		jogo.distribuirMaos();
		
		for(Jogador jogador : jogo.getJogadores()) {
			assertEquals(7, jogador.getMao().size());
		}
	}

	public void testCheckCartaValida_T1() {
		Jogo jogo = new Jogo ();
		
		Jogador jogador = new Jogador();
		Carta cartaMao = new Carta();
		cartaMao.setCor(Cor.VERMELHO);
		cartaMao.setNumero(5);
		cartaMao.setValida(false);
		List<Carta> mao = new ArrayList<Carta>();
		mao.add(cartaMao);
		jogador.setMao(mao);
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador);
		jogo.setJogadores(jogadores);
		
		Stack<Carta> deck = new Stack<Carta>();
//		Carta carta = new Carta();
//		carta.setCor(Cor.AMARELO);
//		carta.setNumero(3);
//		carta.setValida(false);
//		deck.add(carta);
		
		Carta validaDeck = new Carta();
		validaDeck.setCor(Cor.ESPECIAL);
		validaDeck.setEfeito(Efeito.WILD);
		validaDeck.setValida(false);
		deck.add(validaDeck);
		jogo.setDeck(deck);
		
		Carta topoDescarte = new Carta();
		topoDescarte.setCor(Cor.AZUL);
		topoDescarte.setNumero(8);
		topoDescarte.setValida(true);
		Stack<Carta> descarte = new Stack<Carta>();
		descarte.add(topoDescarte);
		jogo.setDescarte(descarte);

		jogo.checkCartaValida(jogador);
		
		/* 
		 * O jogo tenta adicionar uma carta na mão do jogador quando o deck está vazio caso o jogador tenha ou não uma carta válida, gerando uma exceção caso deck está vazio.
		 */
		
		assertEquals(true, jogador.getMao().contains(validaDeck));
		assertEquals(true, validaDeck.isValida());
		
	}

	public void testJogar_T1() {
		Jogo jogo = new Jogo();
		Jogador jogador1 = new Jogador();
		List<Carta> maoJogador1 = new ArrayList<Carta>();
		Carta cartaJogador1 = new Carta();
		cartaJogador1.setCor(Cor.VERMELHO);
		cartaJogador1.setNumero(1);
		cartaJogador1.setValida(false);
		maoJogador1.add(cartaJogador1);
		jogador1.setMao(maoJogador1);
		
		Jogador jogador2 = new Jogador();
		List<Carta> maoJogador2 = new ArrayList<Carta>();
		Carta cartaJogador2 = new Carta();
		cartaJogador2.setCor(Cor.AMARELO);
		cartaJogador2.setNumero(2);
		cartaJogador2.setValida(false);
		maoJogador2.add(cartaJogador2);
		jogador2.setMao(maoJogador2);
		
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		
		Stack<Carta> descarte = new Stack<Carta>();
		Carta topoDescarte = new Carta();
		topoDescarte.setCor(Cor.AZUL);
		topoDescarte.setNumero(3);
		topoDescarte.setValida(true);
		descarte.add(topoDescarte);
		jogo.setDescarte(descarte);
		
		jogo.setJogadorAtual(jogador1);
		jogo.setProximoJogador(jogador2);
		
		jogo.jogar(0);
		
		assertEquals(jogo, jogo);
	}
	
	public void testJogar_T2() {
		Jogo jogo = new Jogo();
		Jogador jogador1 = new Jogador();
		List<Carta> maoJogador1 = new ArrayList<Carta>();
		Carta cartaJogador1 = new Carta();
		cartaJogador1.setCor(Cor.VERMELHO);
		cartaJogador1.setNumero(1);
		cartaJogador1.setValida(true);
		maoJogador1.add(cartaJogador1);
		jogador1.setMao(maoJogador1);
		
		Jogador jogador2 = new Jogador();
		List<Carta> maoJogador2 = new ArrayList<Carta>();
		Carta cartaJogador2 = new Carta();
		cartaJogador2.setCor(Cor.VERMELHO);
		cartaJogador2.setNumero(2);
		cartaJogador2.setValida(false);
		maoJogador2.add(cartaJogador2);
		jogador2.setMao(maoJogador2);
		
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		
		Stack<Carta> descarte = new Stack<Carta>();
		Carta topoDescarte = new Carta();
		topoDescarte.setCor(Cor.VERMELHO);
		topoDescarte.setNumero(3);
		topoDescarte.setValida(true);
		descarte.add(topoDescarte);
		jogo.setDescarte(descarte);
		
		jogo.setJogadorAtual(jogador1);
		jogo.setProximoJogador(jogador2);
		jogo.setSentidoDoJogo(Sentido.HORARIO);
		jogo.setDeck(new Baralho().getDeck());
		
		jogo.jogar(0);
		
		assertEquals(jogador1, jogo.getVencedor());
	}

	public void testJogar_T3() {
		Jogo jogo = new Jogo();
		Jogador jogador1 = new Jogador();
		List<Carta> maoJogador1 = new ArrayList<Carta>();
		Carta carta1Jogador1 = new Carta();
		carta1Jogador1.setCor(Cor.VERMELHO);
		carta1Jogador1.setEfeito(Efeito.SKIP);
		carta1Jogador1.setValida(true);
		maoJogador1.add(carta1Jogador1);
		Carta carta2Jogador1 = new Carta();
		carta2Jogador1.setCor(Cor.VERMELHO);
		carta2Jogador1.setNumero(2);
		carta2Jogador1.setValida(true);
		maoJogador1.add(carta2Jogador1);
		jogador1.setMao(maoJogador1);
		
		Jogador jogador2 = new Jogador();
		List<Carta> maoJogador2 = new ArrayList<Carta>();
		Carta cartaJogador2 = new Carta();
		cartaJogador2.setCor(Cor.VERMELHO);
		cartaJogador2.setNumero(2);
		cartaJogador2.setValida(false);
		maoJogador2.add(cartaJogador2);
		jogador2.setMao(maoJogador2);
		
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		
		Stack<Carta> descarte = new Stack<Carta>();
		Carta topoDescarte = new Carta();
		topoDescarte.setCor(Cor.VERMELHO);
		topoDescarte.setNumero(3);
		topoDescarte.setValida(true);
		descarte.add(topoDescarte);
		jogo.setDescarte(descarte);
		
		jogo.setJogadorAtual(jogador1);
		jogo.setProximoJogador(jogador2);
		jogo.setSentidoDoJogo(Sentido.HORARIO);
		jogo.setDeck(new Baralho().getDeck());
		
		jogo.jogar(0);
		
		assertEquals(jogador1, jogo.getJogadorAtual());
	}
	
	public void testJogar_T4() {
		Jogo jogo = new Jogo();
		Jogador jogador1 = new Jogador();
		List<Carta> maoJogador1 = new ArrayList<Carta>();
		Carta carta1Jogador1 = new Carta();
		carta1Jogador1.setCor(Cor.VERMELHO);
		carta1Jogador1.setEfeito(Efeito.REVERSE);
		carta1Jogador1.setValida(true);
		maoJogador1.add(carta1Jogador1);
		Carta carta2Jogador1 = new Carta();
		carta2Jogador1.setCor(Cor.VERMELHO);
		carta2Jogador1.setNumero(2);
		carta2Jogador1.setValida(true);
		maoJogador1.add(carta2Jogador1);
		jogador1.setMao(maoJogador1);
		
		Jogador jogador2 = new Jogador();
		List<Carta> maoJogador2 = new ArrayList<Carta>();
		Carta cartaJogador2 = new Carta();
		cartaJogador2.setCor(Cor.VERMELHO);
		cartaJogador2.setNumero(2);
		cartaJogador2.setValida(false);
		maoJogador2.add(cartaJogador2);
		jogador2.setMao(maoJogador2);
		
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		
		Stack<Carta> descarte = new Stack<Carta>();
		Carta topoDescarte = new Carta();
		topoDescarte.setCor(Cor.VERMELHO);
		topoDescarte.setNumero(3);
		topoDescarte.setValida(true);
		descarte.add(topoDescarte);
		jogo.setDescarte(descarte);
		
		jogo.setJogadorAtual(jogador1);
		jogo.setProximoJogador(jogador2);
		jogo.setSentidoDoJogo(Sentido.HORARIO);
		jogo.setDeck(new Baralho().getDeck());
		
		jogo.jogar(0);
		
		assertEquals(Sentido.ANTIHORARIO, jogo.getSentidoDoJogo());
	}
	
	public void testJogar_T5() {
		Jogo jogo = new Jogo();
		Jogador jogador1 = new Jogador();
		List<Carta> maoJogador1 = new ArrayList<Carta>();
		Carta carta1Jogador1 = new Carta();
		carta1Jogador1.setCor(Cor.VERMELHO);
		carta1Jogador1.setEfeito(Efeito.REVERSE);
		carta1Jogador1.setValida(true);
		maoJogador1.add(carta1Jogador1);
		Carta carta2Jogador1 = new Carta();
		carta2Jogador1.setCor(Cor.VERMELHO);
		carta2Jogador1.setNumero(2);
		carta2Jogador1.setValida(true);
		maoJogador1.add(carta2Jogador1);
		jogador1.setMao(maoJogador1);
		
		Jogador jogador2 = new Jogador();
		List<Carta> maoJogador2 = new ArrayList<Carta>();
		Carta cartaJogador2 = new Carta();
		cartaJogador2.setCor(Cor.VERMELHO);
		cartaJogador2.setNumero(2);
		cartaJogador2.setValida(false);
		maoJogador2.add(cartaJogador2);
		jogador2.setMao(maoJogador2);
		
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		
		Stack<Carta> descarte = new Stack<Carta>();
		Carta topoDescarte = new Carta();
		topoDescarte.setCor(Cor.VERMELHO);
		topoDescarte.setNumero(3);
		topoDescarte.setValida(true);
		descarte.add(topoDescarte);
		jogo.setDescarte(descarte);
		
		jogo.setJogadorAtual(jogador1);
		jogo.setProximoJogador(jogador2);
		jogo.setSentidoDoJogo(Sentido.ANTIHORARIO);
		jogo.setDeck(new Baralho().getDeck());
		
		jogo.jogar(0);
		
		assertEquals(Sentido.HORARIO, jogo.getSentidoDoJogo());
	}
	
	public void testJogar_T6() {
		Jogo jogo = new Jogo();
		Jogador jogador1 = new Jogador();
		List<Carta> maoJogador1 = new ArrayList<Carta>();
		Carta carta1Jogador1 = new Carta();
		carta1Jogador1.setCor(Cor.VERMELHO);
		carta1Jogador1.setEfeito(Efeito.DRAW_2);
		carta1Jogador1.setValida(true);
		maoJogador1.add(carta1Jogador1);
		Carta carta2Jogador1 = new Carta();
		carta2Jogador1.setCor(Cor.VERMELHO);
		carta2Jogador1.setNumero(2);
		carta2Jogador1.setValida(true);
		maoJogador1.add(carta2Jogador1);
		jogador1.setMao(maoJogador1);
		
		Jogador jogador2 = new Jogador();
		List<Carta> maoJogador2 = new ArrayList<Carta>();
		Carta cartaJogador2 = new Carta();
		cartaJogador2.setCor(Cor.VERMELHO);
		cartaJogador2.setNumero(2);
		cartaJogador2.setValida(false);
		maoJogador2.add(cartaJogador2);
		jogador2.setMao(maoJogador2);
		
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		
		Stack<Carta> descarte = new Stack<Carta>();
		Carta topoDescarte = new Carta();
		topoDescarte.setCor(Cor.VERMELHO);
		topoDescarte.setNumero(3);
		topoDescarte.setValida(true);
		descarte.add(topoDescarte);
		jogo.setDescarte(descarte);
		
		jogo.setJogadorAtual(jogador1);
		jogo.setProximoJogador(jogador2);
		jogo.setSentidoDoJogo(Sentido.HORARIO);
		jogo.setDeck(new Baralho().getDeck());
		
		jogo.jogar(0);
		
		assertEquals(jogador1, jogo.getJogadorAtual());
		assertEquals(3, jogador2.getMao().size());
	}
	
	public void testJogar_T7() {
		Jogo jogo = new Jogo();
		Jogador jogador1 = new Jogador();
		List<Carta> maoJogador1 = new ArrayList<Carta>();
		Carta carta1Jogador1 = new Carta();
		carta1Jogador1.setCor(Cor.ESPECIAL);
		carta1Jogador1.setEfeito(Efeito.WILD);
		carta1Jogador1.setValida(true);
		maoJogador1.add(carta1Jogador1);
		Carta carta2Jogador1 = new Carta();
		carta2Jogador1.setCor(Cor.VERMELHO);
		carta2Jogador1.setNumero(2);
		carta2Jogador1.setValida(true);
		maoJogador1.add(carta2Jogador1);
		jogador1.setMao(maoJogador1);
		
		Jogador jogador2 = new Jogador();
		List<Carta> maoJogador2 = new ArrayList<Carta>();
		Carta cartaJogador2 = new Carta();
		cartaJogador2.setCor(Cor.VERMELHO);
		cartaJogador2.setNumero(2);
		cartaJogador2.setValida(false);
		maoJogador2.add(cartaJogador2);
		jogador2.setMao(maoJogador2);
		
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		
		Stack<Carta> descarte = new Stack<Carta>();
		Carta topoDescarte = new Carta();
		topoDescarte.setCor(Cor.VERMELHO);
		topoDescarte.setNumero(3);
		topoDescarte.setValida(true);
		descarte.add(topoDescarte);
		jogo.setDescarte(descarte);
		
		jogo.setJogadorAtual(jogador1);
		jogo.setProximoJogador(jogador2);
		jogo.setSentidoDoJogo(Sentido.HORARIO);
		jogo.setDeck(new Baralho().getDeck());
		
		jogo.jogar(0);
		
		assertEquals(jogador2, jogo.getJogadorAtual());
		assertEquals(Cor.VERMELHO, jogo.getCorAtual()); // Tem que escolher a cor vermelho
	}
	
	public void testJogar_T8() {
		Jogo jogo = new Jogo();
		Jogador jogador1 = new Jogador();
		List<Carta> maoJogador1 = new ArrayList<Carta>();
		Carta carta1Jogador1 = new Carta();
		carta1Jogador1.setCor(Cor.ESPECIAL);
		carta1Jogador1.setEfeito(Efeito.WILD_DRAW_4);
		carta1Jogador1.setValida(true);
		maoJogador1.add(carta1Jogador1);
		Carta carta2Jogador1 = new Carta();
		carta2Jogador1.setCor(Cor.VERMELHO);
		carta2Jogador1.setNumero(2);
		carta2Jogador1.setValida(true);
		maoJogador1.add(carta2Jogador1);
		jogador1.setMao(maoJogador1);
		
		Jogador jogador2 = new Jogador();
		List<Carta> maoJogador2 = new ArrayList<Carta>();
		Carta cartaJogador2 = new Carta();
		cartaJogador2.setCor(Cor.VERMELHO);
		cartaJogador2.setNumero(2);
		cartaJogador2.setValida(false);
		maoJogador2.add(cartaJogador2);
		jogador2.setMao(maoJogador2);
		
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		
		Stack<Carta> descarte = new Stack<Carta>();
		Carta topoDescarte = new Carta();
		topoDescarte.setCor(Cor.VERMELHO);
		topoDescarte.setNumero(3);
		topoDescarte.setValida(true);
		descarte.add(topoDescarte);
		jogo.setDescarte(descarte);
		
		jogo.setJogadorAtual(jogador1);
		jogo.setProximoJogador(jogador2);
		jogo.setSentidoDoJogo(Sentido.HORARIO);
		jogo.setDeck(new Baralho().getDeck());
		
		jogo.jogar(0);
		
		assertEquals(jogador1, jogo.getJogadorAtual());
		assertEquals(5, jogador2.getMao().size());
		assertEquals(Cor.VERMELHO, jogo.getCorAtual()); // Tem que escolher a cor vermelho
	}
	
	public void testNextJogador_T1(){
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		Jogador jogador2 = new Jogador();
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		jogo.setSentidoDoJogo(Sentido.HORARIO);
		jogo.setJogadorAtual(jogador2);
		
		jogo.nextJogador();
		
		assertEquals(jogador1, jogo.getJogadorAtual());
		assertEquals(jogador2, jogo.getProximoJogador());
	}
	
	public void testNextJogador_T2(){
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		Jogador jogador2 = new Jogador();
		Jogador jogador3 = new Jogador();
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogadores.add(jogador3);
		jogo.setJogadores(jogadores);
		jogo.setSentidoDoJogo(Sentido.HORARIO);
		jogo.setJogadorAtual(jogador2);
		
		jogo.nextJogador();
		
		assertEquals(jogador3, jogo.getJogadorAtual());
		assertEquals(jogador1, jogo.getProximoJogador());
	}
	
	public void testNextJogador_T3(){
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		Jogador jogador2 = new Jogador();
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		jogo.setSentidoDoJogo(Sentido.HORARIO);
		jogo.setJogadorAtual(jogador1);
		
		jogo.nextJogador();
		
		assertEquals(jogador2, jogo.getJogadorAtual());
		assertEquals(jogador1, jogo.getProximoJogador());
	}
	
	public void testNextJogador_T4(){
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		Jogador jogador2 = new Jogador();
		Jogador jogador3 = new Jogador();
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogadores.add(jogador3);
		jogo.setJogadores(jogadores);
		jogo.setSentidoDoJogo(Sentido.ANTIHORARIO);
		jogo.setJogadorAtual(jogador1);
		
		jogo.nextJogador();
		
		assertEquals(jogador3, jogo.getJogadorAtual());
		assertEquals(jogador2, jogo.getProximoJogador());
	}
	
	public void testNextJogador_T5(){
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		Jogador jogador2 = new Jogador();
		Jogador jogador3 = new Jogador();
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogadores.add(jogador3);
		jogo.setJogadores(jogadores);
		jogo.setSentidoDoJogo(Sentido.ANTIHORARIO);
		jogo.setJogadorAtual(jogador2);
		
		jogo.nextJogador();
		
		assertEquals(jogador1, jogo.getJogadorAtual());
		assertEquals(jogador3, jogo.getProximoJogador());
	}
	
	public void testNextJogador_T6(){
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		Jogador jogador2 = new Jogador();
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		jogo.setSentidoDoJogo(Sentido.ANTIHORARIO);
		jogo.setJogadorAtual(jogador2);
		
		jogo.nextJogador();
		
		assertEquals(jogador1, jogo.getJogadorAtual());
		assertEquals(jogador2, jogo.getProximoJogador());
	}
	
	public void testCheckVencedor_T1() {
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		Jogador jogador2 = new Jogador();
		Carta cartaMao = new Carta();
		cartaMao.setCor(Cor.VERMELHO);
		cartaMao.setNumero(5);
		cartaMao.setValida(false);
		List<Carta> mao = new ArrayList<Carta>();
		mao.add(cartaMao);
		jogador2.setMao(mao);
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		
		assertEquals(true, jogo.checkVencedor());
		assertEquals(jogador1, jogo.getVencedor());
	}
	
	public void testCheckVencedor_T2() {
		Jogo jogo = new Jogo ();
		Jogador jogador1 = new Jogador();
		Carta cartaMao = new Carta();
		cartaMao.setCor(Cor.VERMELHO);
		cartaMao.setNumero(5);
		cartaMao.setValida(false);
		List<Carta> mao = new ArrayList<Carta>();
		mao.add(cartaMao);
		jogador1.setMao(mao);
		Jogador jogador2 = new Jogador();
		Carta cartaMao2 = new Carta();
		cartaMao2.setCor(Cor.VERMELHO);
		cartaMao2.setNumero(4);
		cartaMao2.setValida(false);
		List<Carta> mao2 = new ArrayList<Carta>();
		mao2.add(cartaMao2);
		jogador2.setMao(mao2);
		
		List<Jogador> jogadores = new ArrayList<Jogador>();
		jogadores.add(jogador1);
		jogadores.add(jogador2);
		jogo.setJogadores(jogadores);
		
		assertEquals(false, jogo.checkVencedor());
		assertEquals(null, jogo.getVencedor());
	}
}
